package com.pfsoft.leetcode;

import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

/**
 * @author pengfei
 * @date 2022年07月27日 11:45
 * 给定一个表示分数加减运算的字符串 expression ，你需要返回一个字符串形式的计算结果。 
 * <p>
 * 这个结果应该是不可约分的分数，即最简分数。 如果最终结果是一个整数，例如 2，你需要将它转换成分数形式，其分母为 1。所以在上述例子中, 2 应该被转换为 2/1。
 * <p>
 *  
 * <p>
 * 示例 1:
 * <p>
 * 输入: expression = "-1/2+1/2"
 * 输出: "0/1"
 *  示例 2:
 * <p>
 * 输入: expression = "-1/2+1/2+1/3"
 * 输出: "1/3"
 * 示例 3:
 * <p>
 * 输入: expression = "1/3-1/2"
 * 输出: "-1/6"
 *  
 * <p>
 * 提示:
 * <p>
 * 输入和输出字符串只包含 '0' 到 '9' 的数字，以及 '/', '+' 和 '-'。 
 * 输入和输出分数格式均为 ±分子/分母。如果输入的第一个分数或者输出的分数是正数，则 '+' 会被省略掉。
 * 输入只包含合法的最简分数，每个分数的分子与分母的范围是  [1,10]。 如果分母是1，意味着这个分数实际上是一个整数。
 * 输入的分数个数范围是 [1,10]。
 * 最终结果的分子与分母保证是 32 位整数范围内的有效整数。
 */

public class Day1 {

    /**
     * 1、首先需要保证输入符合规则，只能包含 +,-,/ 3个符号和 0~9的数字
     * 2、输入的分数个数范围是 [1,10]
     * 3、输入只包含合法的最简分数，每个分数的分子与分母的范围是[1,10]
     *
     * @return
     */
    private String fractionAddAndSub(String inputExpress) {
        //正则表达式判断输入inputExpress是否符合规则
        if (this.hasInvalidChar(inputExpress)) {
            return "存在不合规的输入字符，请检查";
        }
        if (this.overTen(inputExpress)) {
            return "只允许10个以内的分数计算";
        }
        //补全表达式字符串第一个字符
        inputExpress = this.complementSignal(inputExpress);
        char[] chars = inputExpress.toCharArray();
        List<String>  StringList = new ArrayList<>();
        int count = 0;
        int offset=0;
        for (int i = 0; i < chars.length; i++) {
            if ("+".equals(chars[i]) || "-".equals(chars[i])) {
                if(count>1){
                    StringList.add(inputExpress.substring(offset, i-offset));
                    offset=i;
                }
                count++;
            }
        }
        return "";
//        for(int i=0;i<StringList.size();i++){
//            FractionEntity fractionEntity=new FractionEntity();
//
//            this.fractionCalculate(FractionEntity.(StringList.get(0)), new FractionEntity(StringList.get(1)))
//        }

    }

    /**
     * 是否存在不规则的字符
     *
     * @param expressString
     * @return
     */
    private boolean hasInvalidChar(String expressString) {
        String pattern = "[^0-9+-/]";
        boolean has = Pattern.matches(pattern, expressString);
        return has;
    }

    /**
     * 输入的分数个数范围是 [1,10]
     *
     * @return
     */
    private boolean overTen(String expressString) {
        char[] chars = expressString.toCharArray();
        int count = 0;
        for (int i = 0; i < chars.length; i++) {
            if ("+".equals(chars[i]) || "-".equals(chars[i])) {
                count++;
            }
            if (count > 9) {
                return true;
            }
        }
        return false;
    }

    /**
     * 两个带符号分数进行计算
     * 先把符号部分拿出来
     *
     * @return
     */
    private FractionEntity fractionCalculate(FractionEntity fra1, FractionEntity fra2) {
        //先让分母一致，两数相乘
        FractionEntity result = new FractionEntity();
//        int topNumber = topNumber* fra2.bellowNumber;
        int bellowNumber = fra1.bellowNumber * fra2.bellowNumber;
//        result.setTopNumber(topNumber);
        result.setBellowNumber(bellowNumber);
        //处理分数显示，比如3/12 显示成1/4
        result.setTopNumber(result.topNumber / result.topNumber);
        result.setBellowNumber(result.bellowNumber / result.topNumber);
        return result;
    }

    /**
     * 首字符如果是数字，要在前面增加+ 符号，比如 1/3-1/2 第一个1前面的+号是省略的
     *
     * @param originalString
     * @return
     */
    private String complementSignal(String originalString) {
        if (Pattern.matches("[0-9]", originalString)) {
            originalString = "+" + originalString;
        }
        return originalString;
    }

    class FractionEntity {
        private boolean signal; //+ or -
        private int topNumber;  //分子
        private int bellowNumber;   //分母

        public FractionEntity(){

        }

        public  FractionEntity (String expressionString) {
//            符号位
            if ("-".equals(expressionString.indexOf(0))) {
                this.signal= false;
            } else {
                this.signal= true;
            }
//            去掉符号位之后按照/分组
            expressionString = expressionString.substring(1, expressionString.length() - 1);
            String[] numberArray = expressionString.split("/");
            this.topNumber=Integer.getInteger(numberArray[0]);
            this.bellowNumber=Integer.getInteger(numberArray[1]);
        }


        public boolean isSignal() {
            return signal;
        }

        public void setSignal(boolean signal) {
            this.signal = signal;
        }

        public int getTopNumber() {
            return topNumber;
        }

        public void setTopNumber(int topNumber) {
            this.topNumber = topNumber;
        }

        public int getBellowNumber() {
            return bellowNumber;
        }

        public void setBellowNumber(int bellowNumber) {
            this.bellowNumber = bellowNumber;
        }
    }


}
